/**
 * 验证工具函数
 */

/**
 * 验证是否为空
 * @param {any} value - 值
 * @returns {boolean} 是否为空
 */
export function isEmpty(value) {
  if (value === null || value === undefined) {
    return true;
  }
  if (typeof value === 'string') {
    return value.trim().length === 0;
  }
  if (Array.isArray(value)) {
    return value.length === 0;
  }
  if (typeof value === 'object') {
    return Object.keys(value).length === 0;
  }
  return false;
}

/**
 * 验证是否为数字
 * @param {any} value - 值
 * @returns {boolean} 是否为数字
 */
export function isNumber(value) {
  return typeof value === 'number' && !isNaN(value);
}

/**
 * 验证是否为字符串
 * @param {any} value - 值
 * @returns {boolean} 是否为字符串
 */
export function isString(value) {
  return typeof value === 'string';
}

/**
 * 验证是否为数组
 * @param {any} value - 值
 * @returns {boolean} 是否为数组
 */
export function isArray(value) {
  return Array.isArray(value);
}

/**
 * 验证是否为对象
 * @param {any} value - 值
 * @returns {boolean} 是否为对象
 */
export function isObject(value) {
  return value !== null && typeof value === 'object' && !Array.isArray(value);
}

/**
 * 验证是否为函数
 * @param {any} value - 值
 * @returns {boolean} 是否为函数
 */
export function isFunction(value) {
  return typeof value === 'function';
}

/**
 * 验证是否为邮箱
 * @param {string} email - 邮箱
 * @returns {boolean} 是否为邮箱
 */
export function isEmail(email) {
  if (!isString(email)) {
    return false;
  }
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
}

/**
 * 验证是否为手机号
 * @param {string} phone - 手机号
 * @returns {boolean} 是否为手机号
 */
export function isPhone(phone) {
  if (!isString(phone)) {
    return false;
  }
  const phoneRegex = /^1[3-9]\d{9}$/;
  return phoneRegex.test(phone);
}

/**
 * 验证是否为URL
 * @param {string} url - URL
 * @returns {boolean} 是否为URL
 */
export function isUrl(url) {
  if (!isString(url)) {
    return false;
  }
  try {
    new URL(url);
    return true;
  } catch {
    return false;
  }
}

/**
 * 验证是否为身份证号
 * @param {string} idCard - 身份证号
 * @returns {boolean} 是否为身份证号
 */
export function isIdCard(idCard) {
  if (!isString(idCard)) {
    return false;
  }
  const idCardRegex = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;
  return idCardRegex.test(idCard);
}

/**
 * 验证长度范围
 * @param {string|Array} value - 值
 * @param {number} min - 最小长度
 * @param {number} max - 最大长度
 * @returns {boolean} 是否在长度范围内
 */
export function isLength(value, min, max) {
  if (isEmpty(value)) {
    return false;
  }
  const length = value.length;
  return length >= min && length <= max;
}

/**
 * 验证数值范围
 * @param {number} value - 值
 * @param {number} min - 最小值
 * @param {number} max - 最大值
 * @returns {boolean} 是否在数值范围内
 */
export function isRange(value, min, max) {
  if (!isNumber(value)) {
    return false;
  }
  return value >= min && value <= max;
}

/**
 * 验证正则表达式
 * @param {string} value - 值
 * @param {RegExp} regex - 正则表达式
 * @returns {boolean} 是否匹配
 */
export function isMatch(value, regex) {
  if (!isString(value)) {
    return false;
  }
  return regex.test(value);
}

/**
 * 验证密码强度
 * @param {string} password - 密码
 * @param {Object} options - 选项
 * @returns {Object} 验证结果
 */
export function validatePassword(password, options = {}) {
  const {
    minLength = 8,
    requireUppercase = true,
    requireLowercase = true,
    requireNumbers = true,
    requireSpecialChars = true,
  } = options;

  const result = {
    isValid: true,
    errors: [],
  };

  if (!isString(password)) {
    result.isValid = false;
    result.errors.push('密码必须是字符串');
    return result;
  }

  if (password.length < minLength) {
    result.isValid = false;
    result.errors.push(`密码长度至少${minLength}位`);
  }

  if (requireUppercase && !/[A-Z]/.test(password)) {
    result.isValid = false;
    result.errors.push('密码必须包含大写字母');
  }

  if (requireLowercase && !/[a-z]/.test(password)) {
    result.isValid = false;
    result.errors.push('密码必须包含小写字母');
  }

  if (requireNumbers && !/\d/.test(password)) {
    result.isValid = false;
    result.errors.push('密码必须包含数字');
  }

  if (requireSpecialChars && !/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
    result.isValid = false;
    result.errors.push('密码必须包含特殊字符');
  }

  return result;
}

/**
 * 表单验证器
 * @param {Object} data - 数据
 * @param {Object} rules - 验证规则
 * @returns {Object} 验证结果
 */
export function validateForm(data, rules) {
  const result = {
    isValid: true,
    errors: {},
  };

  for (const field in rules) {
    const fieldRules = rules[field];
    const value = data[field];
    const fieldErrors = [];

    for (const rule of fieldRules) {
      const { type, message, ...options } = rule;

      let isValid = true;

      switch (type) {
        case 'required':
          isValid = !isEmpty(value);
          break;
        case 'email':
          isValid = isEmpty(value) || isEmail(value);
          break;
        case 'phone':
          isValid = isEmpty(value) || isPhone(value);
          break;
        case 'url':
          isValid = isEmpty(value) || isUrl(value);
          break;
        case 'length':
          isValid = isEmpty(value) || isLength(value, options.min, options.max);
          break;
        case 'range':
          isValid = isEmpty(value) || isRange(value, options.min, options.max);
          break;
        case 'pattern':
          isValid = isEmpty(value) || isMatch(value, options.regex);
          break;
        case 'custom':
          isValid = isEmpty(value) || options.validator(value);
          break;
      }

      if (!isValid) {
        fieldErrors.push(message);
        result.isValid = false;
      }
    }

    if (fieldErrors.length > 0) {
      result.errors[field] = fieldErrors;
    }
  }

  return result;
}
